package com.mm.cloth.api;

import android.content.Context;
import android.content.SharedPreferences;
import android.util.Log;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.mm.cloth.utils.ApiDebugInterceptor;
import com.mm.cloth.utils.TokenManager;

import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.concurrent.TimeUnit;

import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
import org.json.JSONObject;
import org.json.JSONException;

/**
 * API客户端
 * 负责创建和配置OkHttp实例和Retrofit实例
 */
public class ApiClient {

    private static final String TAG = "ApiClient";

    // API基础URL和端口，参考UniApp项目的配置
    public static String BASE_HOST = "layshen.fun";  // 添加默认值
    public static int BASE_PORT = 10913;             // 添加默认值
    public static String BASE_URL = "http://" + BASE_HOST + ":" + BASE_PORT;

    public static final String API_PATH = "/";

    // 增加请求超时时间（秒），从6秒增加到30秒
    private static final int TIMEOUT = 30;

    // 单例实例
    private static ApiClient instance;

    // OkHttpClient实例
    private OkHttpClient okHttpClient;

    // Retrofit实例
    private Retrofit retrofit;

    // ApiService实例
    private ApiService apiService;

    // 应用上下文，用于获取token
    private static Context appContext;

    /**
     * 私有构造方法，初始化OkHttpClient和Retrofit
     */
    private ApiClient() {
        try {
            Log.d(TAG, "ApiClient构造函数开始");

            // 创建自定义Gson实例，确保正确解析嵌套对象
            Gson gson = new GsonBuilder()
                    .setLenient() // 允许解析非严格格式的JSON
                    // 移除excludeFieldsWithoutExposeAnnotation限制，允许所有字段被序列化和反序列化
                    .create();

            // 创建OkHttpClient，配置超时时间
            okHttpClient = new OkHttpClient.Builder()
                    .connectTimeout(TIMEOUT, TimeUnit.SECONDS)
                    .readTimeout(TIMEOUT, TimeUnit.SECONDS)
                    .writeTimeout(TIMEOUT, TimeUnit.SECONDS)
                    .addInterceptor(new AuthInterceptor()) // 总是添加认证拦截器
                    .addInterceptor(new ApiDebugInterceptor()) // 添加调试拦截器
                    .build();

            Log.d(TAG, "OkHttpClient创建完成，已添加AuthInterceptor");

            // 创建Retrofit实例，使用自定义Gson
            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL + API_PATH)
                    .client(okHttpClient)
                    .addConverterFactory(GsonConverterFactory.create(gson))
                    .build();

            // 创建ApiService实例
            apiService = retrofit.create(ApiService.class);

            Log.d(TAG, "ApiClient构造函数完成");

        } catch (Exception e) {
            Log.e(TAG, "ApiClient初始化失败", e);
            throw e;
        }
    }

    /**
     * 初始化ApiClient，设置应用上下文
     * @param context 应用上下文
     */
    public static void init(Context context) {
        Log.d(TAG, "ApiClient.init()开始");

        try {
            appContext = context.getApplicationContext();
            Log.d(TAG, "appContext设置成功: " + appContext);

            BASE_URL = "http://" + BASE_HOST + ":" + BASE_PORT;
            // AuthInterceptor已经在构造函数中添加，这里只需要设置context
            // 不需要重新创建OkHttpClient和Retrofit
            Log.d(TAG, "=====准备出实话retrofit===== " + BASE_URL);
            if (instance != null) {
                instance.reinitializeRetrofit();
            }

        } catch (Exception e) {
            Log.e(TAG, "ApiClient初始化失败", e);
            throw e;
        }

        Log.d(TAG, "ApiClient.init()完成");
    }

    /**
     * 设置基础URL配置
     * @param configJson 包含域名和端口的JSON字符串
     */
    public static void setBaseUrlConfiguration(String configJson) {
        try {
            // 解析JSON配置
            JSONObject config = new JSONObject(configJson);
            String host = config.getString("host");
            int port = config.getInt("port");
            
            // 更新基础主机和端口
            BASE_HOST = host;
            BASE_PORT = port;
            
            // 重新构建BASE_URL
            BASE_URL = "http://" + BASE_HOST + ":" + BASE_PORT;
            
            Log.d(TAG, "更新BASE_URL为: " + BASE_URL);
            
            // 重新初始化Retrofit实例
            if (instance != null) {
                instance.reinitializeRetrofit();
            }
            
        } catch (JSONException e) {
            Log.e(TAG, "解析基础URL配置失败", e);
            Log.e(TAG, "配置解析失败: " + e.getMessage());
        } catch (Exception e) {
            Log.e(TAG, "设置基础URL配置时发生未知错误", e);
        }
    }

    /**
     * 重新初始化Retrofit实例
     */
    public static void reinitializeRetrofit() {
        // 创建自定义Gson实例，确保正确解析嵌套对象
        Gson gson = new GsonBuilder()
                .setLenient() // 允许解析非严格格式的JSON
                // 移除excludeFieldsWithoutExposeAnnotation限制，允许所有字段被序列化和反序列化
                .create();
        
        // 创建新的OkHttpClient
        OkHttpClient newClient = new OkHttpClient.Builder()
                .connectTimeout(TIMEOUT, TimeUnit.SECONDS)
                .readTimeout(TIMEOUT, TimeUnit.SECONDS)
                .writeTimeout(TIMEOUT, TimeUnit.SECONDS)
                .addInterceptor(new AuthInterceptor())
                .addInterceptor(new ApiDebugInterceptor())
                .build();
        
        // 创建新的Retrofit实例，使用自定义Gson
        instance.retrofit = new Retrofit.Builder()
                .baseUrl(BASE_URL + API_PATH)
                .client(newClient)
                .addConverterFactory(GsonConverterFactory.create(gson))
                .build();
        
        // 重新创建ApiService实例
        instance.apiService = instance.retrofit.create(ApiService.class);
    }

    /**
     * 获取单例实例
     * @return ApiClient实例
     */
    public static synchronized ApiClient getInstance() {
        if (instance == null) {
            instance = new ApiClient();
        }
        return instance;
    }

    public ApiService getApiService() {
        return apiService;
    }

    /**
     * 获取OkHttpClient实例
     * @return OkHttpClient实例
     */
    public OkHttpClient getOkHttpClient() {
        return okHttpClient;
    }

    /**
     * 获取完整的API URL
     * @param path API路径
     * @return 完整的API URL
     */
    public static String getApiUrl(String path) {
        return BASE_URL + API_PATH + path;
    }

    /**
     * 认证拦截器，自动添加Authorization头
     * 除了登录、注册、系统配置等公开接口外，其他接口都需要token
     */
    private static class AuthInterceptor implements Interceptor {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request originalRequest = chain.request();
            String url = originalRequest.url().toString();

            Log.d(TAG, "=== API请求拦截 ===");
            Log.d(TAG, "请求URL: " + url);
            Log.d(TAG, "请求方法: " + originalRequest.method());

            // 判断是否为不需要token的公开接口
            if (isPublicEndpoint(url)) {
                Log.d(TAG, "✅ 公开接口，无需token: " + url);
                return chain.proceed(originalRequest);
            }

            Log.d(TAG, "🔒 需要认证的接口，开始获取token...");

            // 获取token
            String token = getTokenFromStorage();

            Log.d(TAG, "Token获取结果: " + (token != null ? "成功 (长度:" + token.length() + ")" : "失败"));

            // 如果有token，添加到请求头
            if (token != null && !token.isEmpty()) {
                Request newRequest = originalRequest.newBuilder()
                        .addHeader("Authorization", "Bearer " + token)
                        .build();
                Log.d(TAG, "✅ 已添加Authorization头到请求: " + url);
                Log.d(TAG, "Authorization: Bearer " + token.substring(0, Math.min(10, token.length())) + "...");
                return chain.proceed(newRequest);
            } else {
                Log.w(TAG, "❌ 需要token但未找到有效token: " + url);
                Log.w(TAG, "请检查用户是否已登录或token是否已过期");
                return chain.proceed(originalRequest);
            }
        }

        /**
         * 判断是否为公开接口（不需要token）
         */
        private boolean isPublicEndpoint(String url) {
            return url.contains("/api/user/login") ||
                    url.contains("/api/user/register") ||
                    url.contains("/api/system/config");
        }

        /**
         * 从本地存储获取token
         */
        private String getTokenFromStorage() {
            if (appContext == null) {
                Log.w(TAG, "appContext为null，无法获取token，可能是在init()调用之前使用了ApiClient");
                return null;
            }

            // 使用TokenManager获取token，它会自动处理过期检查
            return TokenManager.getToken(appContext);
        }
    }
}